Termination w.r.t. Q proof of TRS/secret05cime3.trs

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
MARK₁(d) -> A__D
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X2)
A__B -> A__D
MARK₁(c) -> A__C
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X1)
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
MARK₁(a) -> A__A
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X3)
A__A¹ -> A__F₁(a__b)
A__H₂(X, X) -> A__F₁(a__k)
A__H₂(X, X) -> MARK₁(X)
MARK₁(h₂(X1, X2)) -> A__H₂(mark₁(X1), mark₁(X2))
A__A -> A__D
A__A¹ -> A__B
MARK₁(b) -> A__B
A__A -> A__C
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)
A__A¹ -> A__F₁(a__a)
A__B -> A__C
MARK₁(A) -> A__A¹
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__F₁(X) -> MARK₁(X)
MARK₁(k) -> A__K
A__A¹ -> A__A
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
MARK₁(h₂(X1, X2)) -> MARK₁(X1)
A__H₂(X, X) -> A__K
A__G₃(d, X, X) -> A__A¹
A__Z₂(e, X) -> MARK₁(X)
MARK₁(g₃(X1, X2, X3)) -> A__G₃(mark₁(X1), mark₁(X2), mark₁(X3))
MARK₁(h₂(X1, X2)) -> MARK₁(X2)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
MARK₁(d) -> A__D
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X2)
A__B -> A__D
MARK₁(c) -> A__C
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X1)
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
MARK₁(a) -> A__A
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X3)
A__A¹ -> A__F₁(a__b)
A__H₂(X, X) -> A__F₁(a__k)
A__H₂(X, X) -> MARK₁(X)
MARK₁(h₂(X1, X2)) -> A__H₂(mark₁(X1), mark₁(X2))
A__A -> A__D
A__A¹ -> A__B
MARK₁(b) -> A__B
A__A -> A__C
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)
A__A¹ -> A__F₁(a__a)
A__B -> A__C
MARK₁(A) -> A__A¹
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__F₁(X) -> MARK₁(X)
MARK₁(k) -> A__K
A__A¹ -> A__A
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
MARK₁(h₂(X1, X2)) -> MARK₁(X1)
A__H₂(X, X) -> A__K
A__G₃(d, X, X) -> A__A¹
A__Z₂(e, X) -> MARK₁(X)
MARK₁(g₃(X1, X2, X3)) -> A__G₃(mark₁(X1), mark₁(X2), mark₁(X3))
MARK₁(h₂(X1, X2)) -> MARK₁(X2)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 1 SCC with 12 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
A__A¹ -> A__F₁(a__a)
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X2)
MARK₁(A) -> A__A¹
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X1)
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
A__F₁(X) -> MARK₁(X)
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X3)
A__A¹ -> A__F₁(a__b)
A__H₂(X, X) -> A__F₁(a__k)
A__H₂(X, X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
MARK₁(h₂(X1, X2)) -> MARK₁(X1)
MARK₁(h₂(X1, X2)) -> A__H₂(mark₁(X1), mark₁(X2))
A__G₃(d, X, X) -> A__A¹
A__Z₂(e, X) -> MARK₁(X)
MARK₁(g₃(X1, X2, X3)) -> A__G₃(mark₁(X1), mark₁(X2), mark₁(X3))
MARK₁(h₂(X1, X2)) -> MARK₁(X2)
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

MARK₁(g₃(X1, X2, X3)) -> MARK₁(X2)
MARK₁(A) -> A__A¹
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X1)
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X3)
MARK₁(h₂(X1, X2)) -> MARK₁(X1)
MARK₁(h₂(X1, X2)) -> A__H₂(mark₁(X1), mark₁(X2))
MARK₁(g₃(X1, X2, X3)) -> A__G₃(mark₁(X1), mark₁(X2), mark₁(X3))
MARK₁(h₂(X1, X2)) -> MARK₁(X2)

The remaining pairs can at least be oriented weakly.

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
A__A¹ -> A__F₁(a__a)
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
A__F₁(X) -> MARK₁(X)
A__A¹ -> A__F₁(a__b)
A__H₂(X, X) -> A__F₁(a__k)
A__H₂(X, X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
A__G₃(d, X, X) -> A__A¹
A__Z₂(e, X) -> MARK₁(X)
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)

Used ordering: Polynomial interpretation [21]:

POL(A) = 1
POL(A__A¹) = 0
POL(A__F₁(x₁)) = 2·x₁
POL(A__G₃(x₁, x₂, x₃)) = 0
POL(A__H₂(x₁, x₂)) = 2·x₂
POL(A__Z₂(x₁, x₂)) = 2·x₂
POL(MARK₁(x₁)) = 2·x₁
POL(a) = 0
POL(a__A) = 1
POL(a__a) = 0
POL(a__b) = 0
POL(a__c) = 0
POL(a__d) = 0
POL(a__f₁(x₁)) = 3·x₁
POL(a__g₃(x₁, x₂, x₃)) = 1 + 2·x₁ + x₂ + 2·x₃
POL(a__h₂(x₁, x₂)) = 1 + x₁ + 2·x₂
POL(a__k) = 0
POL(a__z₂(x₁, x₂)) = 2·x₁ + x₂
POL(b) = 0
POL(c) = 0
POL(d) = 0
POL(e) = 0
POL(f₁(x₁)) = 3·x₁
POL(g₃(x₁, x₂, x₃)) = 1 + 2·x₁ + x₂ + 2·x₃
POL(h₂(x₁, x₂)) = 1 + x₁ + 2·x₂
POL(k) = 0
POL(l) = 0
POL(m) = 0
POL(mark₁(x₁)) = x₁
POL(z₂(x₁, x₂)) = 2·x₁ + x₂

The following usable rules [14] were oriented:

mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
a__c -> c
mark₁(a) -> a__a
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__g₃(d, X, X) -> a__A
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__d -> d
a__k -> l
a__k -> m
a__a -> a
a__a -> a__c
mark₁(k) -> a__k
a__c -> l
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)
a__f₁(X) -> f₁(X)
mark₁(A) -> a__A
a__z₂(X1, X2) -> z₂(X1, X2)
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
a__b -> a__c
mark₁(l) -> l
a__b -> a__d
mark₁(e) -> e
a__A -> A
mark₁(b) -> a__b
a__h₂(X1, X2) -> h₂(X1, X2)
a__a -> a__d
mark₁(d) -> a__d
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(c) -> a__c
a__k -> k
a__b -> b
a__c -> e
a__d -> m
mark₁(m) -> m

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
A__A¹ -> A__F₁(a__a)
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
A__F₁(X) -> MARK₁(X)
A__A¹ -> A__F₁(a__b)
A__H₂(X, X) -> A__F₁(a__k)
A__H₂(X, X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
A__G₃(d, X, X) -> A__A¹
A__Z₂(e, X) -> MARK₁(X)
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 2 SCCs with 4 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ AND

                  ↳ QDP

                    ↳ QDPOrderProof

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

A__Z₂(e, X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__F₁(X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

A__Z₂(e, X) -> MARK₁(X)

The remaining pairs can at least be oriented weakly.

MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__F₁(X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)

Used ordering: Polynomial interpretation [21]:

POL(A) = 0
POL(A__F₁(x₁)) = 2·x₁
POL(A__Z₂(x₁, x₂)) = x₁ + x₂
POL(MARK₁(x₁)) = x₁
POL(a) = 2
POL(a__A) = 0
POL(a__a) = 2
POL(a__b) = 2
POL(a__c) = 2
POL(a__d) = 0
POL(a__f₁(x₁)) = 3·x₁
POL(a__g₃(x₁, x₂, x₃)) = 0
POL(a__h₂(x₁, x₂)) = 0
POL(a__k) = 0
POL(a__z₂(x₁, x₂)) = 2·x₁ + x₂
POL(b) = 2
POL(c) = 2
POL(d) = 0
POL(e) = 1
POL(f₁(x₁)) = 3·x₁
POL(g₃(x₁, x₂, x₃)) = 0
POL(h₂(x₁, x₂)) = 0
POL(k) = 0
POL(l) = 0
POL(m) = 0
POL(mark₁(x₁)) = x₁
POL(z₂(x₁, x₂)) = 2·x₁ + x₂

The following usable rules [14] were oriented:

mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
a__c -> c
mark₁(a) -> a__a
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__g₃(d, X, X) -> a__A
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__d -> d
a__k -> l
a__k -> m
a__a -> a
a__a -> a__c
mark₁(k) -> a__k
a__c -> l
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)
a__f₁(X) -> f₁(X)
mark₁(A) -> a__A
a__z₂(X1, X2) -> z₂(X1, X2)
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
a__b -> a__c
mark₁(l) -> l
a__b -> a__d
mark₁(e) -> e
a__A -> A
mark₁(b) -> a__b
a__h₂(X1, X2) -> h₂(X1, X2)
a__a -> a__d
mark₁(d) -> a__d
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(c) -> a__c
a__k -> k
a__b -> b
a__c -> e
a__d -> m
mark₁(m) -> m

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ AND

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ DependencyGraphProof

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__F₁(X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 1 SCC with 2 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ AND

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ DependencyGraphProof

                          ↳ QDP

                            ↳ QDPOrderProof

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__F₁(X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
MARK₁(f₁(X)) -> MARK₁(X)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

MARK₁(f₁(X)) -> A__F₁(mark₁(X))
MARK₁(f₁(X)) -> MARK₁(X)

The remaining pairs can at least be oriented weakly.

A__F₁(X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)

Used ordering: Polynomial interpretation [21]:

POL(A) = 0
POL(A__F₁(x₁)) = 2·x₁
POL(MARK₁(x₁)) = 2·x₁
POL(a) = 0
POL(a__A) = 0
POL(a__a) = 0
POL(a__b) = 0
POL(a__c) = 0
POL(a__d) = 0
POL(a__f₁(x₁)) = 1 + 3·x₁
POL(a__g₃(x₁, x₂, x₃)) = 0
POL(a__h₂(x₁, x₂)) = 0
POL(a__k) = 0
POL(a__z₂(x₁, x₂)) = 2·x₁ + x₂
POL(b) = 0
POL(c) = 0
POL(d) = 0
POL(e) = 0
POL(f₁(x₁)) = 1 + 3·x₁
POL(g₃(x₁, x₂, x₃)) = 0
POL(h₂(x₁, x₂)) = 0
POL(k) = 0
POL(l) = 0
POL(m) = 0
POL(mark₁(x₁)) = x₁
POL(z₂(x₁, x₂)) = 2·x₁ + x₂

The following usable rules [14] were oriented:

mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
a__c -> c
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__g₃(d, X, X) -> a__A
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
mark₁(a) -> a__a
a__d -> d
a__k -> l
a__k -> m
a__a -> a
a__a -> a__c
mark₁(k) -> a__k
a__c -> l
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)
a__f₁(X) -> f₁(X)
mark₁(A) -> a__A
a__z₂(X1, X2) -> z₂(X1, X2)
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
a__b -> a__c
mark₁(l) -> l
a__b -> a__d
mark₁(e) -> e
a__A -> A
mark₁(b) -> a__b
a__h₂(X1, X2) -> h₂(X1, X2)
a__a -> a__d
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(d) -> a__d
mark₁(c) -> a__c
a__k -> k
a__b -> b
a__c -> e
a__d -> m
mark₁(m) -> m

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ AND

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ DependencyGraphProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ DependencyGraphProof

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

A__F₁(X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ AND

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ DependencyGraphProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MARK₁(z₂(X1, X2)) -> MARK₁(X1)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

MARK₁(z₂(X1, X2)) -> MARK₁(X1)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(MARK₁(x₁)) = 2·x₁
POL(z₂(x₁, x₂)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ AND

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ DependencyGraphProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ PisEmptyProof

                  ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ AND

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
A__G₃(d, X, X) -> A__A¹

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.